import { useState } from "react";
import {
  fetchUserStatus,
  fetchPlanList,
  updateUserSettings,
  fetchPlanData,
  generatePlan,
  markUserNotNew,
  updatePlanLevel, // 添加导入
} from "../services/api";

interface Plan {
  plans: string[];
  intro: string[];
  user_level: number; // 确保 Plan 接口与 api.ts 一致
}

interface AvailablePlan {
  lang: string;
  direction: string;
}

// 修改 hook 签名以接受 userId
export function usePlan(userId: string | null) {
  // --- 状态定义 ---
  const [language, setLanguage] = useState("");
  const [direction, setDirection] = useState("");
  const [isLoading, setIsLoading] = useState(true);
  const [loadingMessage, setLoadingMessage] = useState("正在加载应用...");
  const [plan, setPlan] = useState<Plan | null>(null);
  const [hoveredIntro, setHoveredIntro] = useState("");
  const [selectedIndex, setSelectedIndex] = useState<number | null>(null);
  const [isNewUser, setIsNewUser] = useState<boolean | null>(null);
  const [userLevel, setUserLevel] = useState<number>(-1);
  const [showMainInterface, setShowMainInterface] = useState(false);
  const [selectedPlanIndex, setSelectedPlanIndex] = useState<number | null>(null);
  const [availablePlans, setAvailablePlans] = useState<AvailablePlan[]>([]);
  const [needsPlanSelection, setNeedsPlanSelection] = useState(false);


  // --- 初始化数据加载 ---
  const fetchInitialData = async () => {
    // 确保 userId 存在
    if (!userId) {
      console.error("fetchInitialData: userId is null, cannot proceed.");
      setIsLoading(false);
      // 可能需要设置错误状态或重定向到登录
      return;
    }

    setIsLoading(true);
    setLoadingMessage("正在检查用户状态...");

    try {
      const fetchedStatus = await fetchUserStatus(userId); // 传递 userId
      console.log("已获取用户状态:", fetchedStatus);

      setIsNewUser(fetchedStatus.is_new_user);
      // 从状态中设置初始语言、方向和等级
      setLanguage(fetchedStatus.lang || "");
      setDirection(fetchedStatus.direction || "");
      // 使用从 status 获取的 level，如果为 null 则设为 -1 或 0
      setUserLevel(fetchedStatus.user_level ?? -1); // 使用 ?? 提供默认值

      if (fetchedStatus.is_new_user) {
        // 新用户，显示语言/方向选择表单
        setNeedsPlanSelection(false);
        setShowMainInterface(false);
        console.log("新用户，准备生成计划。");
      } else {
        // 老用户
        if (fetchedStatus.lang) {
          // 如果老用户已设置语言，尝试直接加载该计划
          setLoadingMessage("正在加载您当前的计划...");
          try {
            // fetchPlanData 现在只需要 userId
            const planData = await fetchPlanData(userId); // 传递 userId
            setPlan(planData);
            // 从加载的计划数据中更新 userLevel (这是最准确的来源)
            setUserLevel(planData.user_level);
            setSelectedPlanIndex(planData.user_level); // 设置初始选中的索引
            setShowMainInterface(true); // 直接显示主界面
            setNeedsPlanSelection(false);
            console.log("已加载现有计划:", planData);
          } catch (planError) {
            // 如果加载特定计划失败（例如文件丢失），则显示计划列表
            console.error(`加载计划 ${fetchedStatus.lang}/${fetchedStatus.direction} 失败:`, planError);
            setLoadingMessage("加载当前计划失败，正在查找可用计划...");
            const plansList = await fetchPlanList(userId); // 传递 userId
            if (plansList.length > 0) {
              setAvailablePlans(plansList);
              setNeedsPlanSelection(true); // 显示计划选择界面
              setShowMainInterface(false);
            } else {
              // 没有找到任何计划文件，显示生成界面
              console.log("未找到任何计划文件，请生成新计划。");
              setNeedsPlanSelection(false);
              setShowMainInterface(false); // 显示生成表单
            }
          }
        } else {
          // 老用户但未设置语言，显示计划列表（如果存在）
          setLoadingMessage("正在查找可用计划...");
          const plansList = await fetchPlanList(userId); // 传递 userId
          if (plansList.length > 0) {
            setAvailablePlans(plansList);
            setNeedsPlanSelection(true); // 显示计划选择界面
            setShowMainInterface(false);
          } else {
            // 没有找到任何计划文件，显示生成界面
            console.log("未找到任何计划文件，请生成新计划。");
            setNeedsPlanSelection(false);
            setShowMainInterface(false); // 显示生成表单
          }
        }
      }
    } catch (error) {
      console.error("初始化失败:", error);
      alert(`加载应用时出错: ${error instanceof Error ? error.message : '未知错误'}`);
      // 出错时回退到新用户流程
      setIsNewUser(true);
      setNeedsPlanSelection(false);
      setShowMainInterface(false);
    } finally {
      setIsLoading(false);
    }
  };

  // --- 事件处理函数 ---
  const handleGeneratePlan = async () => {
    setIsLoading(true);
    setLoadingMessage("正在生成计划...");
    setPlan(null);
    setSelectedIndex(null);
    setHoveredIntro("");

    try {
      // 确保 userId 存在
      if (!userId) throw new Error("无法生成计划：用户未登录。");
      const result = await generatePlan(userId, language, direction); // 传递 userId
      setPlan(result);
      // 从生成的计划数据中设置 userLevel
      setUserLevel(result.user_level);
    } catch (error) {
      console.error("生成计划失败:", error);
      alert(`生成计划时出错: ${error instanceof Error ? error.message : '未知错误'}`);
    } finally {
      setIsLoading(false);
    }
  };

  const handleConfirmSelection = async () => {
    if (selectedIndex === null) {
      alert("请先选择一个计划点！");
      return;
    }

    setIsLoading(true);
    setLoadingMessage("正在保存您的选择...");

    try {
      // 确保 userId 存在
      if (!userId) throw new Error("无法确认选择：用户未登录。");

      // 不再传递 level (selectedIndex 被错误地用作 level)
      await updateUserSettings(userId, language, direction); // 传递 userId

      if (isNewUser) {
        console.log("新用户首次确认，正在标记为非新用户...");
        await markUserNotNew(userId); // 传递 userId
        setIsNewUser(false);
      } else {
        console.log("老用户创建新计划，跳过标记步骤。");
      }

     // 在更新设置和标记新用户后，更新计划等级
     await updatePlanLevel(userId, selectedIndex); // 使用 selectedIndex 更新 level
     console.log(`用户等级已更新为: ${selectedIndex}`);

     // 更新本地状态以匹配后端
     setUserLevel(selectedIndex); // 更新本地 userLevel 状态
     setSelectedPlanIndex(selectedIndex);
     setShowMainInterface(true);
   } catch (error) {
     console.error("确认操作失败:", error);
      alert(`操作失败: ${error instanceof Error ? error.message : '未知错误'}`);
    } finally {
      setIsLoading(false);
    }
  };

  const handlePlanSelection = async (selectedPlan: AvailablePlan) => {
    setIsLoading(true);
    setLoadingMessage("正在加载所选计划...");

    try {
      // 更新语言和方向状态
      setLanguage(selectedPlan.lang);
      setDirection(selectedPlan.direction || '');

      // 确保 userId 存在
      if (!userId) throw new Error("无法选择计划：用户未登录。");

      // 获取计划数据 - 只需要 userId
      const planData = await fetchPlanData(userId); // 传递 userId
      setPlan(planData);
      // 从加载的计划数据中设置 userLevel
      setUserLevel(planData.user_level);

      // 更新用户设置（仅 lang 和 direction）
      await updateUserSettings(userId, selectedPlan.lang, selectedPlan.direction); // 传递 userId

      // 更新界面状态
      // 使用从 planData 获取的 level
      setSelectedPlanIndex(planData.user_level);
      setNeedsPlanSelection(false);
      setShowMainInterface(true);
    } catch (error) {
      console.error("选择计划失败:", error);
      alert(`加载所选计划时出错: ${error instanceof Error ? error.message : '未知错误'}`);
    } finally {
      setIsLoading(false);
    }
  };

  const handleCreateNewTask = () => {
    setShowMainInterface(false);
    setNeedsPlanSelection(false);
    setPlan(null);
    setLanguage("");
    setDirection("");
    setSelectedIndex(null);
    setHoveredIntro("");
    setSelectedPlanIndex(null);
    console.log("触发创建新任务流程");
  };

  const handleGoBackToPlanSelection = async () => {
    setIsLoading(true);
    setLoadingMessage("正在加载计划列表...");

    try {
      // 确保 userId 存在
      if (!userId) throw new Error("无法加载计划列表：用户未登录。");
      const plansList = await fetchPlanList(userId); // 传递 userId
      setAvailablePlans(plansList);
      setShowMainInterface(false);
      setNeedsPlanSelection(true);
      setPlan(null);
      setSelectedPlanIndex(null);
      console.log("返回到计划选择界面");
    } catch (error) {
      console.error("加载计划列表失败:", error);
      alert(`加载计划列表时出错: ${error instanceof Error ? error.message : '未知错误'}`);
    } finally {
      setIsLoading(false);
    }
  };

  // 新增：处理计划等级更新的函数
  const handleLevelUpdate = async (newLevel: number) => {
    setIsLoading(true);
    setLoadingMessage("正在更新您的进度...");

    try {
      // 确保 userId 存在
      if (!userId) throw new Error("无法更新等级：用户未登录。");
      // 调用新的 API 服务函数
      await updatePlanLevel(userId, newLevel); // 传递 userId

      // 更新本地状态
      setUserLevel(newLevel);
      setSelectedPlanIndex(newLevel); // 假设 selectedPlanIndex 也反映了当前 level
      console.log(`计划等级已成功更新为: ${newLevel}`);
    } catch (error) {
      console.error("更新计划等级失败:", error);
      alert(`更新进度时出错: ${error instanceof Error ? error.message : '未知错误'}`);
      // 可选：如果更新失败，可能需要将状态回滚或通知用户
    } finally {
      setIsLoading(false);
    }
  };


  return {
    // 状态
    language,
    direction,
    isLoading,
    loadingMessage,
    plan,
    hoveredIntro,
    selectedIndex,
    isNewUser,
    userLevel,
    showMainInterface,
    selectedPlanIndex,
    availablePlans,
    needsPlanSelection,

    // 状态更新函数
    setLanguage,
    setDirection,
    setHoveredIntro,
    setSelectedIndex,
    setPlan,
    setSelectedPlanIndex,
    // 方法
    fetchInitialData,
    handleGeneratePlan,
    handleConfirmSelection,
    handlePlanSelection,
    handleCreateNewTask,
    handleGoBackToPlanSelection,
    handleLevelUpdate, // 导出新函数
  };
};